Backup and Restore NVIDIA Jetson Orin NX/Nano on JetPack 6+

Introduction

In this tutorial, we will create and deploy a golden image for an NVIDIA Jetson Orin NX/Nano module running JetPack 6+.
This guide uses two separate flows:
- First, flash and prepare the source Jetson with SDK Manager, then create a backup from its NVMe.
- Second, restore that backup to another Jetson and flash its QSPI bootloader components from the same Linux_for_Tegra folder.
By the end, the target Jetson should boot from the restored NVMe image using the matching JetPack 6+ bootloader components.

What You Will Need

Before starting the deployment process, make sure you have the following:

Ubuntu Linux host machine
A host PC running Ubuntu with NVIDIA SDK Manager installed.
NVIDIA SDK Manager
Used to flash the source Jetson and prepare the JetPack 6+ Linux_for_Tegra folder.
Linux_for_Tegra directory
Run all backup, restore, and QSPI commands from the same JetPack 6+ Linux_for_Tegra directory on the host machine.
Source Jetson Orin NX/Nano module
The Jetson that will be flashed with SDK Manager, configured, validated, and used as the golden image source.
Target Jetson Orin NX/Nano module
Another Jetson that will receive the restored image and QSPI bootloader components.
NVMe storage
Source and target NVMe devices should be connected as nvme0n1.
USB recovery connection
Each Jetson must be connected to the host machine over USB and placed into recovery mode when flashing, backing up, or restoring.

NOTE: The backup, restore, and QSPI flashing commands in this tutorial must be run from the same Linux_for_Tegra folder generated/prepared for JetPack 6+.

Section 1: Flash the Source Jetson and Create the Golden Backup

Step 1: Flash JetPack 6+ with SDK Manager

Connect the source Jetson Orin NX/Nano to the Ubuntu host machine.
Put the source Jetson into recovery mode using the carrier board recovery procedure.
Open NVIDIA SDK Manager on the host machine.
Select the correct Jetson Orin NX/Nano target hardware and JetPack 6+.
Apply the BSP if required.
Flash the source Jetson using SDK Manager.
Complete the first-boot setup and apply any required project configuration.
Validate that the source Jetson is working correctly before using it as the golden image.

NOTE: The source Jetson should be fully configured and validated before creating the backup. Any configuration present on the source image will be copied to the target Jetson during restore.

Step 2: Open the JetPack 6+ Linux_for_Tegra Folder

On the Ubuntu host machine, open a terminal.
Navigate to the Linux_for_Tegra directory that was created or used by SDK Manager:
```
cd Linux_for_Tegra
```
Confirm that the backup and restore tool exists:
```
ls tools/backup_restore/l4t_backup_restore.sh
```

Step 3: Put the Source Jetson into Recovery Mode

Power off the source Jetson.
Connect the Jetson recovery USB port to the host machine.
Put the source Jetson into recovery mode.
Verify that the host detects the Jetson in recovery mode:
```
lsusb
```

Step 4: Create the NVMe Backup

Run the following command from the Linux_for_Tegra directory to create a backup of the source NVMe:
```
sudo ./tools/backup_restore/l4t_backup_restore.sh -e nvme0n1 -b jetson-orin-nano-devkit-nvme
```

NOTE: This operation can take a long time depending on the NVMe capacity and host storage performance. Make sure the host has enough free disk space before starting.

After the command completes, keep the generated backup files in the backup/restore tool directory.
This backup is the golden image that will be restored to the target Jetson.

Section 2: Restore the Backup to Another Jetson and Flash QSPI

Step 1: Prepare the Target Jetson

Power off the target Jetson Orin NX/Nano.
Install the target NVMe storage.
Connect the target Jetson recovery USB port to the host machine.
Put the target Jetson into recovery mode.
Verify that the host detects the target Jetson:
```
lsusb
```

Step 2: Use the Same Linux_for_Tegra Folder

On the Ubuntu host machine, use the same Linux_for_Tegra directory that was used to create the backup:
```
cd Linux_for_Tegra
```

WARNING: The restore and QSPI commands below must be run from the same Linux_for_Tegra folder that contains the backup created in Section 1.

Step 3: Restore the Golden Image to the Target NVMe

Run the restore command from the same Linux_for_Tegra directory:

sudo ./tools/backup_restore/l4t_backup_restore.sh -e nvme0n1 -r jetson-orin-nano-devkit-nvme

WARNING: Restoring the image overwrites the target NVMe. Make sure the correct target Jetson and NVMe device are connected before running the command.

Wait until the restore process completes successfully.

Step 4: Flash the Target QSPI Bootloader Components

Keep the target Jetson in recovery mode.

From the same Linux_for_Tegra directory, flash the bootloader/QSPI components without flashing the system image:

sudo ./flash.sh -c bootloader/generic/cfg/flash_t234_qspi.xml --no-systemimg jetson-orin-nano-devkit-nvme internal

NOTE: This step updates the target Jetson QSPI bootloader components only. The system image is not flashed because the command uses --no-systemimg.

Step 5: First Boot Validation

Power-cycle the target Jetson.
Allow the system to boot from the restored NVMe.
Log in locally or over SSH.
Confirm the JetPack / L4T version:
```
cat /etc/nv_tegra_release
```
Confirm that the NVMe root filesystem is mounted:
```
findmnt /
```
Confirm that the expected NVMe device is present:
```
lsblk
```

Step 6: Deployment Validation Checklist

Verify that the system boots without entering recovery mode.
Verify that the application services start correctly.
Verify network connectivity.
Verify storage layout and available disk space:
```
df -h
```
Verify Jetson power mode if required by the deployment:
```
sudo nvpmodel -q
```

Troubleshooting

Host Does Not Detect the Jetson in Recovery Mode

Reconnect the recovery USB cable.
Confirm the carrier board recovery-mode sequence.
Run:
```
lsusb
```

Backup or Restore Fails or Cannot Find the NVMe

Confirm that the NVMe is installed correctly.
Confirm the device name:
```
lsblk
```
Make sure the command uses the expected device name:
```
-e nvme0n1
```

Target Does Not Boot After Restore

Confirm that the restore command completed successfully.
Repeat the QSPI flashing step from the same Linux_for_Tegra directory.
Confirm that the target module is compatible with the JetPack 6+ BSP used to create the backup.
Confirm that the restored NVMe image was created from a compatible Jetson Orin NX/Nano source system.

Summary

In this guide, we prepared a Jetson Orin NX/Nano deployment workflow for JetPack 6+:

Flashed the source Jetson with SDK Manager.
Created a golden NVMe backup using the -b backup command.
Restored the golden image to another Jetson using the -r restore command.
Flashed the target Jetson QSPI bootloader components from the same Linux_for_Tegra folder.
Validated that the deployed system boots and runs correctly.

Introduction​

What You Will Need​

Section 1: Flash the Source Jetson and Create the Golden Backup​

Step 1: Flash JetPack 6+ with SDK Manager​

Step 2: Open the JetPack 6+ Linux_for_Tegra Folder​

Step 3: Put the Source Jetson into Recovery Mode​

Step 4: Create the NVMe Backup​

Section 2: Restore the Backup to Another Jetson and Flash QSPI​

Step 1: Prepare the Target Jetson​

Step 2: Use the Same Linux_for_Tegra Folder​

Step 3: Restore the Golden Image to the Target NVMe​

Step 4: Flash the Target QSPI Bootloader Components​

Step 5: First Boot Validation​

Step 6: Deployment Validation Checklist​

Troubleshooting​

Host Does Not Detect the Jetson in Recovery Mode​

Backup or Restore Fails or Cannot Find the NVMe​

Target Does Not Boot After Restore​

Summary​